---
title: "控制流 - 條件語句、迴圈和模式匹配"
description: "學習 Swift 控制流：條件語句、迴圈、switch 語句和模式匹配，與 JavaScript 對比"
---

# 控制流：條件語句、迴圈和模式匹配

在本模組中，我們將探索 Swift 的控制流結構，並與 JavaScript 的條件語句和迴圈進行對比。Swift 提供了強大的控制流功能，包括增強的 switch 語句和模式匹配，比 JavaScript 的 switch 語句更加表達力強。

## 目錄

- [條件語句](#條件語句)
- [迴圈](#迴圈)
- [Switch 語句](#switch-語句)
- [模式匹配](#模式匹配)
- [控制轉移語句](#控制轉移語句)
- [錯誤處理基礎](#錯誤處理基礎)
- [練習題](#練習題)
- [關鍵要點](#關鍵要點)

## 條件語句

Swift 的條件語句與 JavaScript 類似，但在語法和行為上有一些關鍵差異。

### If 語句

<UniversalEditor title="If 語句對比" compare={true}>
```javascript !! js
// JavaScript if 語句
let age = 25;
let hasLicense = true;

// 基本 if 語句
if (age >= 18) {
    console.log("你是成年人");
}

// If-else 語句
if (age >= 18) {
    console.log("你可以投票");
} else {
    console.log("你還不能投票");
}

// If-else if-else 鏈
if (age < 13) {
    console.log("兒童");
} else if (age < 20) {
    console.log("青少年");
} else if (age < 65) {
    console.log("成年人");
} else {
    console.log("老年人");
}

// 帶邏輯運算符的條件
if (age >= 18 && hasLicense) {
    console.log("你可以開車");
} else {
    console.log("你不能開車");
}

// 三元運算符
let status = age >= 18 ? "成年人" : "未成年人";
```

```swift !! swift
// Swift if 語句
let age = 25
let hasLicense = true

// 基本 if 語句
if age >= 18 {
    print("你是成年人")
}

// If-else 語句
if age >= 18 {
    print("你可以投票")
} else {
    print("你還不能投票")
}

// If-else if-else 鏈
if age < 13 {
    print("兒童")
} else if age < 20 {
    print("青少年")
} else if age < 65 {
    print("成年人")
} else {
    print("老年人")
}

// 帶邏輯運算符的條件
if age >= 18 && hasLicense {
    print("你可以開車")
} else {
    print("你不能開車")
}

// 三元運算符
let status = age >= 18 ? "成年人" : "未成年人"

// Swift 特有：if 語句中的可選綁定
let optionalName: String? = "John"
if let name = optionalName {
    print("你好，\(name)")
} else {
    print("沒有提供姓名")
}

// 多個可選綁定
let optionalAge: Int? = 25
let optionalCity: String? = "New York"
if let age = optionalAge, let city = optionalCity {
    print("\(age) 歲，來自 \(city)")
}
```
</UniversalEditor>

### Guard 語句

Swift 的 guard 語句是一個強大的控制流特性，在 JavaScript 中不存在。

<UniversalEditor title="Guard 語句" compare={true}>
```javascript !! js
// JavaScript: 早期返回模式（相當於 guard）
function processUser(user) {
    // 早期返回進行驗證
    if (!user) {
        return "沒有提供用戶";
    }
    
    if (!user.name) {
        return "用戶沒有姓名";
    }
    
    if (!user.email) {
        return "用戶沒有郵箱";
    }
    
    // 主要邏輯在這裡
    return `處理用戶: ${user.name} (${user.email})`;
}

// 使用
const user1 = { name: "John", email: "john@example.com" };
const user2 = { name: "Jane" };
console.log(processUser(user1)); // "處理用戶: John (john@example.com)"
console.log(processUser(user2)); // "用戶沒有郵箱"
```

```swift !! swift
// Swift guard 語句
func processUser(_ user: [String: Any]?) -> String {
    // Guard 用於早期退出
    guard let user = user else {
        return "沒有提供用戶"
    }
    
    guard let name = user["name"] as? String else {
        return "用戶沒有姓名"
    }
    
    guard let email = user["email"] as? String else {
        return "用戶沒有郵箱"
    }
    
    // 主要邏輯在這裡 - user、name 和 email 都可用
    return "處理用戶: \(name) (\(email))"
}

// 使用
let user1: [String: Any] = ["name": "John", "email": "john@example.com"]
let user2: [String: Any] = ["name": "Jane"]
print(processUser(user1)) // "處理用戶: John (john@example.com)"
print(processUser(user2)) // "用戶沒有郵箱"

// 帶多個條件的 guard
func validateUser(_ user: [String: Any]) -> Bool {
    guard let name = user["name"] as? String,
          let age = user["age"] as? Int,
          age >= 18 else {
        return false
    }
    
    // 所有驗證都通過
    return true
}
```
</UniversalEditor>

## 迴圈

Swift 提供了幾種類型的迴圈，每種都有特定的用例和效能特徵。

### For 迴圈

<UniversalEditor title="For 迴圈對比" compare={true}>
```javascript !! js
// JavaScript for 迴圈
let numbers = [1, 2, 3, 4, 5];

// 傳統 for 迴圈
for (let i = 0; i < numbers.length; i++) {
    console.log(numbers[i]);
}

// For...of 迴圈（遍歷值）
for (let number of numbers) {
    console.log(number);
}

// For...in 迴圈（遍歷索引/鍵）
for (let index in numbers) {
    console.log(`索引 ${index}: ${numbers[index]}`);
}

// ForEach 方法
numbers.forEach((number, index) => {
    console.log(`數字 ${index}: ${number}`);
});

// 基於範圍的迴圈
for (let i = 1; i <= 5; i++) {
    console.log(i);
}

// 遍歷物件屬性
let person = { name: "John", age: 30, city: "NYC" };
for (let key in person) {
    console.log(`${key}: ${person[key]}`);
}
```

```swift !! swift
// Swift for 迴圈
let numbers = [1, 2, 3, 4, 5]

// For-in 迴圈（遍歷值）
for number in numbers {
    print(number)
}

// For-in 帶索引
for (index, number) in numbers.enumerated() {
    print("索引 \(index): \(number)")
}

// 基於範圍的迴圈
for i in 1...5 {
    print(i)
}

// 半開範圍
for i in 1..<5 {
    print(i) // 列印 1, 2, 3, 4
}

// Stride 自訂範圍
for i in stride(from: 0, to: 10, by: 2) {
    print(i) // 列印 0, 2, 4, 6, 8
}

// 遍歷字典
let person: [String: Any] = ["name": "John", "age": 30, "city": "NYC"]
for (key, value) in person {
    print("\(key): \(value)")
}

// ForEach 方法（函數式方法）
numbers.enumerated().forEach { index, number in
    print("數字 \(index): \(number)")
}

// Swift 特有：for 迴圈中的 where 子句
for number in numbers where number % 2 == 0 {
    print("偶數: \(number)")
}
```
</UniversalEditor>

### While 和 Repeat-While 迴圈

<UniversalEditor title="While 迴圈對比" compare={true}>
```javascript !! js
// JavaScript while 迴圈
let count = 0;

// While 迴圈
while (count < 5) {
    console.log(count);
    count++;
}

// Do-while 迴圈（至少執行一次）
let number = 0;
do {
    console.log(number);
    number++;
} while (number < 3);

// While 迴圈帶 break
let i = 0;
while (true) {
    if (i >= 5) {
        break;
    }
    console.log(i);
    i++;
}

// While 迴圈帶 continue
let j = 0;
while (j < 10) {
    j++;
    if (j % 2 === 0) {
        continue; // 跳過偶數
    }
    console.log(j);
}
```

```swift !! swift
// Swift while 迴圈
var count = 0

// While 迴圈
while count < 5 {
    print(count)
    count += 1
}

// Repeat-while 迴圈（至少執行一次）
var number = 0
repeat {
    print(number)
    number += 1
} while number < 3

// While 迴圈帶 break
var i = 0
while true {
    if i >= 5 {
        break
    }
    print(i)
    i += 1
}

// While 迴圈帶 continue
var j = 0
while j < 10 {
    j += 1
    if j % 2 == 0 {
        continue // 跳過偶數
    }
    print(j)
}

// Swift 特有：帶可選綁定的 while 迴圈
var optionalNumbers: [Int?] = [1, nil, 3, nil, 5]
var index = 0
while index < optionalNumbers.count {
    if let number = optionalNumbers[index] {
        print("找到數字: \(number)")
    }
    index += 1
}
```
</UniversalEditor>

## Switch 語句

Swift 的 switch 語句比 JavaScript 的更加強大，支援模式匹配和複雜條件。

### 基本 Switch 語句

<UniversalEditor title="基本 Switch 語句" compare={true}>
```javascript !! js
// JavaScript switch 語句
let day = "Monday";

switch (day) {
    case "Monday":
        console.log("工作週開始");
        break;
    case "Tuesday":
    case "Wednesday":
    case "Thursday":
        console.log("週中");
        break;
    case "Friday":
        console.log("TGIF!");
        break;
    case "Saturday":
    case "Sunday":
        console.log("週末!");
        break;
    default:
        console.log("無效的日期");
}

// Switch 帶 fall-through（顯式）
let grade = "B";
switch (grade) {
    case "A":
        console.log("優秀");
        // Fall through
    case "B":
        console.log("良好");
        break;
    case "C":
        console.log("一般");
        break;
    default:
        console.log("需要改進");
}
```

```swift !! swift
// Swift switch 語句
let day = "Monday"

switch day {
case "Monday":
    print("工作週開始")
case "Tuesday", "Wednesday", "Thursday":
    print("週中")
case "Friday":
    print("TGIF!")
case "Saturday", "Sunday":
    print("週末!")
default:
    print("無效的日期")
}

// Switch 帶 fallthrough（顯式）
let grade = "B"
switch grade {
case "A":
    print("優秀")
    fallthrough
case "B":
    print("良好")
case "C":
    print("一般")
default:
    print("需要改進")
}

// Swift 特有：帶範圍的 Switch
let score = 85
switch score {
case 90...100:
    print("A")
case 80..<90:
    print("B")
case 70..<80:
    print("C")
case 60..<70:
    print("D")
case 0..<60:
    print("F")
default:
    print("無效分數")
}

// Switch 帶元組
let point = (2, 0)
switch point {
case (0, 0):
    print("原點")
case (_, 0):
    print("在 x 軸上")
case (0, _):
    print("在 y 軸上")
case (-2...2, -2...2):
    print("靠近原點")
default:
    print("其他地方")
}
```
</UniversalEditor>

### 高級 Switch 和模式匹配

<UniversalEditor title="高級 Switch 和模式匹配" compare={true}>
```javascript !! js
// JavaScript: 複雜條件邏輯（沒有直接等價物）
function processValue(value) {
    if (typeof value === "string") {
        if (value.length === 0) {
            return "空字串";
        } else if (value.length < 10) {
            return "短字串";
        } else {
            return "長字串";
        }
    } else if (typeof value === "number") {
        if (value === 0) {
            return "零";
        } else if (value > 0) {
            return "正數";
        } else {
            return "負數";
        }
    } else if (Array.isArray(value)) {
        if (value.length === 0) {
            return "空陣列";
        } else {
            return `包含 ${value.length} 個元素的陣列`;
        }
    } else if (value === null) {
        return "空值";
    } else {
        return "未知類型";
    }
}

// 使用
console.log(processValue("hello")); // "短字串"
console.log(processValue(42)); // "正數"
console.log(processValue([1, 2, 3])); // "包含 3 個元素的陣列"
```

```swift !! swift
// Swift: 帶模式匹配的高級 switch
func processValue(_ value: Any) -> String {
    switch value {
    case let str as String:
        switch str {
        case "":
            return "空字串"
        case let s where s.count < 10:
            return "短字串"
        default:
            return "長字串"
        }
    case let num as Int:
        switch num {
        case 0:
            return "零"
        case let n where n > 0:
            return "正數"
        default:
            return "負數"
        }
    case let arr as [Any]:
        switch arr {
        case []:
            return "空陣列"
        case let a where a.count > 0:
            return "包含 \(a.count) 個元素的陣列"
        default:
            return "未知陣列"
        }
    case nil:
        return "空值"
    default:
        return "未知類型"
    }
}

// 使用
print(processValue("hello")) // "短字串"
print(processValue(42)) // "正數"
print(processValue([1, 2, 3])) // "包含 3 個元素的陣列"

// 帶列舉的 Switch 模式匹配
enum Direction {
    case north, south, east, west
}

func describeDirection(_ direction: Direction) -> String {
    switch direction {
    case .north:
        return "向上"
    case .south:
        return "向下"
    case .east:
        return "向右"
    case .west:
        return "向左"
    }
}

// 帶關聯值的 Switch
enum Measurement {
    case distance(Double)
    case temperature(Double)
    case weight(Double)
}

func describeMeasurement(_ measurement: Measurement) -> String {
    switch measurement {
    case .distance(let value):
        return "距離: \(value) 公尺"
    case .temperature(let value):
        return "溫度: \(value)°C"
    case .weight(let value):
        return "重量: \(value) 公斤"
    }
}
```
</UniversalEditor>

## 模式匹配

Swift 的模式匹配能力遠超 JavaScript 中可用的功能。

### 值綁定和 Where 子句

<UniversalEditor title="值綁定和 Where 子句" compare={true}>
```javascript !! js
// JavaScript: 複雜條件邏輯
function analyzeNumber(num) {
    if (typeof num === "number") {
        if (num === 0) {
            return "零";
        } else if (num > 0 && num < 100) {
            return `小正數: ${num}`;
        } else if (num >= 100 && num < 1000) {
            return `中等正數: ${num}`;
        } else if (num >= 1000) {
            return `大正數: ${num}`;
        } else {
            return `負數: ${num}`;
        }
    }
    return "不是數字";
}

// 複雜物件分析
function analyzePerson(person) {
    if (person && typeof person === "object") {
        const { name, age, city } = person;
        if (name && age && city) {
            if (age < 18) {
                return `${name} 是來自 ${city} 的未成年人`;
            } else if (age >= 18 && age < 65) {
                return `${name} 是來自 ${city} 的成年人`;
            } else {
                return `${name} 是來自 ${city} 的老年人`;
            }
        }
    }
    return "無效的人員資料";
}
```

```swift !! swift
// Swift: 帶值綁定的模式匹配
func analyzeNumber(_ num: Int) -> String {
    switch num {
    case 0:
        return "零"
    case let n where n > 0 && n < 100:
        return "小正數: \(n)"
    case let n where n >= 100 && n < 1000:
        return "中等正數: \(n)"
    case let n where n >= 1000:
        return "大正數: \(n)"
    case let n where n < 0:
        return "負數: \(n)"
    default:
        return "意外情況"
    }
}

// 複雜元組模式匹配
func analyzePerson(_ person: (name: String, age: Int, city: String)) -> String {
    switch person {
    case let (name, age, city) where age < 18:
        return "\(name) 是來自 \(city) 的未成年人"
    case let (name, age, city) where age >= 18 && age < 65:
        return "\(name) 是來自 \(city) 的成年人"
    case let (name, age, city) where age >= 65:
        return "\(name) 是來自 \(city) 的老年人"
    default:
        return "無效的人員資料"
    }
}

// 陣列模式匹配
func analyzeArray(_ array: [Int]) -> String {
    switch array {
    case []:
        return "空陣列"
    case [let first]:
        return "單個元素: \(first)"
    case [let first, let second]:
        return "兩個元素: \(first), \(second)"
    case let arr where arr.count > 2:
        return "包含 \(arr.count) 個元素的陣列"
    default:
        return "未知陣列"
    }
}

// 可選類型模式匹配
func analyzeOptional(_ value: Int?) -> String {
    switch value {
    case nil:
        return "沒有值"
    case let num? where num > 0:
        return "正數: \(num)"
    case let num? where num < 0:
        return "負數: \(num)"
    case 0?:
        return "零"
    default:
        return "意外情況"
    }
}
```
</UniversalEditor>

## 控制轉移語句

Swift 提供了幾種控制轉移語句來管理程式流程。

### Break、Continue 和 Fallthrough

<UniversalEditor title="控制轉移語句" compare={true}>
```javascript !! js
// JavaScript 控制轉移
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// 迴圈中的 break
for (let i = 0; i < numbers.length; i++) {
    if (numbers[i] === 5) {
        break; // 找到 5 時退出迴圈
    }
    console.log(numbers[i]);
}

// 迴圈中的 continue
for (let i = 0; i < numbers.length; i++) {
    if (numbers[i] % 2 === 0) {
        continue; // 跳過偶數
    }
    console.log(numbers[i]);
}

// Switch 中的 break（顯式）
let day = "Monday";
switch (day) {
    case "Monday":
        console.log("週開始");
        break; // 需要顯式 break
    case "Friday":
        console.log("週結束");
        break;
    default:
        console.log("週中");
}

// 標記語句
outerLoop: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (i === 1 && j === 1) {
            break outerLoop; // 跳出外層迴圈
        }
        console.log(`i=${i}, j=${j}`);
    }
}
```

```swift !! swift
// Swift 控制轉移
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// 迴圈中的 break
for number in numbers {
    if number == 5 {
        break // 找到 5 時退出迴圈
    }
    print(number)
}

// 迴圈中的 continue
for number in numbers {
    if number % 2 == 0 {
        continue // 跳過偶數
    }
    print(number)
}

// Switch 中的 break（隱式，無 fallthrough）
let day = "Monday"
switch day {
case "Monday":
    print("週開始")
    // 不需要 break，隱式
case "Friday":
    print("週結束")
default:
    print("週中")
}

// Fallthrough（顯式）
let grade = "A"
switch grade {
case "A":
    print("優秀")
    fallthrough // 顯式 fallthrough
case "B":
    print("良好")
case "C":
    print("一般")
default:
    print("需要改進")
}

// 標記語句
outerLoop: for i in 0..<3 {
    for j in 0..<3 {
        if i == 1 && j == 1 {
            break outerLoop // 跳出外層迴圈
        }
        print("i=\(i), j=\(j)")
    }
}

// Swift 特有：帶值的 break（在 switch 中）
enum Result {
    case success(String)
    case failure(String)
}

func processResult(_ result: Result) -> String {
    switch result {
    case .success(let message):
        return "成功: \(message)"
    case .failure(let error):
        return "錯誤: \(error)"
    }
}
```
</UniversalEditor>

## 錯誤處理基礎

Swift 的錯誤處理比 JavaScript 的 try-catch 更加結構化。

<UniversalEditor title="錯誤處理對比" compare={true}>
```javascript !! js
// JavaScript 錯誤處理
function divideNumbers(a, b) {
    if (b === 0) {
        throw new Error("除零錯誤");
    }
    return a / b;
}

// Try-catch
try {
    const result = divideNumbers(10, 0);
    console.log(result);
} catch (error) {
    console.log("錯誤:", error.message);
}

// Try-catch with finally
try {
    const result = divideNumbers(10, 2);
    console.log("結果:", result);
} catch (error) {
    console.log("錯誤:", error.message);
} finally {
    console.log("清理完成");
}

// 自訂錯誤類型
class ValidationError extends Error {
    constructor(message) {
        super(message);
        this.name = "ValidationError";
    }
}

function validateAge(age) {
    if (age < 0) {
        throw new ValidationError("年齡不能為負數");
    }
    if (age > 150) {
        throw new ValidationError("年齡似乎不現實");
    }
    return true;
}
```

```swift !! swift
// Swift 錯誤處理
enum DivisionError: Error {
    case divisionByZero
    case invalidInput
}

func divideNumbers(_ a: Double, _ b: Double) throws -> Double {
    guard b != 0 else {
        throw DivisionError.divisionByZero
    }
    return a / b
}

// Do-catch
do {
    let result = try divideNumbers(10, 0)
    print(result)
} catch DivisionError.divisionByZero {
    print("錯誤: 除零錯誤")
} catch {
    print("錯誤: \(error)")
}

// Try with 可選綁定
if let result = try? divideNumbers(10, 2) {
    print("結果: \(result)")
} else {
    print("發生錯誤")
}

// Force try（如果錯誤會崩潰）
let result = try! divideNumbers(10, 2) // 這裡安全

// 自訂錯誤類型
enum ValidationError: Error {
    case negativeAge
    case unrealisticAge(Int)
    case missingName
}

func validateAge(_ age: Int) throws {
    if age < 0 {
        throw ValidationError.negativeAge
    }
    if age > 150 {
        throw ValidationError.unrealisticAge(age)
    }
}

func validatePerson(name: String?, age: Int) throws {
    guard let name = name, !name.isEmpty else {
        throw ValidationError.missingName
    }
    try validateAge(age)
    print("有效人員: \(name)，年齡 \(age)")
}

// 帶模式匹配的錯誤處理
do {
    try validatePerson(name: nil, age: 25)
} catch ValidationError.negativeAge {
    print("年齡不能為負數")
} catch ValidationError.unrealisticAge(let age) {
    print("年齡 \(age) 似乎不現實")
} catch ValidationError.missingName {
    print("需要姓名")
} catch {
    print("未知錯誤: \(error)")
}
```
</UniversalEditor>

## 練習題

### 練習 1：成績計算器
建立一個函數，接受分數並使用 switch 語句返回等級。

<UniversalEditor title="練習 1 解答" compare={true}>
```javascript !! js
// JavaScript 解答
function getGrade(score) {
    switch (true) {
        case score >= 90:
            return "A";
        case score >= 80:
            return "B";
        case score >= 70:
            return "C";
        case score >= 60:
            return "D";
        case score >= 0:
            return "F";
        default:
            return "無效分數";
    }
}

// 測試
console.log(getGrade(95)); // "A"
console.log(getGrade(85)); // "B"
console.log(getGrade(75)); // "C"
console.log(getGrade(65)); // "D"
console.log(getGrade(55)); // "F"
```

```swift !! swift
// Swift 解答
func getGrade(_ score: Int) -> String {
    switch score {
    case 90...100:
        return "A"
    case 80..<90:
        return "B"
    case 70..<80:
        return "C"
    case 60..<70:
        return "D"
    case 0..<60:
        return "F"
    default:
        return "無效分數"
    }
}

// 測試
print(getGrade(95)) // "A"
print(getGrade(85)) // "B"
print(getGrade(75)) // "C"
print(getGrade(65)) // "D"
print(getGrade(55)) // "F"
```
</UniversalEditor>

### 練習 2：數字分析器
建立一個函數，使用模式匹配分析數字並返回描述。

<UniversalEditor title="練習 2 解答" compare={true}>
```javascript !! js
// JavaScript 解答
function analyzeNumber(num) {
    if (typeof num !== "number") {
        return "不是數字";
    }
    
    if (num === 0) {
        return "零";
    } else if (num > 0) {
        if (num % 2 === 0) {
            return "正偶數";
        } else {
            return "正奇數";
        }
    } else {
        if (num % 2 === 0) {
            return "負偶數";
        } else {
            return "負奇數";
        }
    }
}

// 測試
console.log(analyzeNumber(0)); // "零"
console.log(analyzeNumber(4)); // "正偶數"
console.log(analyzeNumber(7)); // "正奇數"
console.log(analyzeNumber(-2)); // "負偶數"
console.log(analyzeNumber(-3)); // "負奇數"
```

```swift !! swift
// Swift 解答
func analyzeNumber(_ num: Int) -> String {
    switch num {
    case 0:
        return "零"
    case let n where n > 0 && n % 2 == 0:
        return "正偶數"
    case let n where n > 0 && n % 2 != 0:
        return "正奇數"
    case let n where n < 0 && n % 2 == 0:
        return "負偶數"
    case let n where n < 0 && n % 2 != 0:
        return "負奇數"
    default:
        return "意外情況"
    }
}

// 測試
print(analyzeNumber(0)) // "零"
print(analyzeNumber(4)) // "正偶數"
print(analyzeNumber(7)) // "正奇數"
print(analyzeNumber(-2)) // "負偶數"
print(analyzeNumber(-3)) // "負奇數"
```
</UniversalEditor>

### 練習 3：陣列處理器
建立一個函數，使用不同的控制流模式處理陣列。

<UniversalEditor title="練習 3 解答" compare={true}>
```javascript !! js
// JavaScript 解答
function processArray(arr) {
    if (!Array.isArray(arr)) {
        return "不是陣列";
    }
    
    if (arr.length === 0) {
        return "空陣列";
    }
    
    let sum = 0;
    let hasNegative = false;
    let hasPositive = false;
    
    for (let num of arr) {
        if (typeof num !== "number") {
            continue; // 跳過非數字
        }
        
        sum += num;
        
        if (num < 0) {
            hasNegative = true;
        } else if (num > 0) {
            hasPositive = true;
        }
    }
    
    if (hasNegative && hasPositive) {
        return "混合陣列，總和: " + sum;
    } else if (hasPositive) {
        return "全正數，總和: " + sum;
    } else if (hasNegative) {
        return "全負數，總和: " + sum;
    } else {
        return "全零，總和: " + sum;
    }
}

// 測試
console.log(processArray([1, 2, 3])); // "全正數，總和: 6"
console.log(processArray([-1, -2, -3])); // "全負數，總和: -6"
console.log(processArray([1, -2, 3])); // "混合陣列，總和: 2"
console.log(processArray([0, 0, 0])); // "全零，總和: 0"
```

```swift !! swift
// Swift 解答
func processArray(_ arr: [Any]) -> String {
    switch arr {
    case []:
        return "空陣列"
    case let array where array.allSatisfy({ $0 is Int }):
        let numbers = array.compactMap { $0 as? Int }
        let sum = numbers.reduce(0, +)
        
        let hasNegative = numbers.contains { $0 < 0 }
        let hasPositive = numbers.contains { $0 > 0 }
        
        switch (hasNegative, hasPositive) {
        case (true, true):
            return "混合陣列，總和: \(sum)"
        case (false, true):
            return "全正數，總和: \(sum)"
        case (true, false):
            return "全負數，總和: \(sum)"
        case (false, false):
            return "全零，總和: \(sum)"
        }
    default:
        return "不是數字陣列"
    }
}

// 使用 guard 的替代方法
func processArrayWithGuard(_ arr: [Any]) -> String {
    guard !arr.isEmpty else {
        return "空陣列"
    }
    
    var sum = 0
    var hasNegative = false
    var hasPositive = false
    
    for element in arr {
        guard let num = element as? Int else {
            continue // 跳過非數字
        }
        
        sum += num
        
        if num < 0 {
            hasNegative = true
        } else if num > 0 {
            hasPositive = true
        }
    }
    
    if hasNegative && hasPositive {
        return "混合陣列，總和: \(sum)"
    } else if hasPositive {
        return "全正數，總和: \(sum)"
    } else if hasNegative {
        return "全負數，總和: \(sum)"
    } else {
        return "全零，總和: \(sum)"
    }
}

// 測試
print(processArray([1, 2, 3])) // "全正數，總和: 6"
print(processArray([-1, -2, -3])) // "全負數，總和: -6"
print(processArray([1, -2, 3])) // "混合陣列，總和: 2"
print(processArray([0, 0, 0])) // "全零，總和: 0"
```
</UniversalEditor>

## 關鍵要點

### Swift 控制流優勢
1. **模式匹配**：強大的 switch 語句，支援複雜模式匹配
2. **Guard 語句**：早期退出模式，程式碼更清晰
3. **值綁定**：直接在 switch case 中提取值
4. **Where 子句**：模式匹配中的附加條件
5. **窮盡匹配**：編譯器確保處理所有情況

### 與 JavaScript 的關鍵差異
1. **Switch 語句**：功能更強大，支援模式匹配
2. **Guard 語句**：JavaScript 中沒有等價物
3. **Fallthrough**：switch 語句中顯式 vs 隱式
4. **錯誤處理**：結構化的 try-catch 和 do-catch 塊
5. **模式匹配**：JavaScript 中不可用的高級匹配功能

### 最佳實踐
1. **使用 guard 語句**進行早期驗證和退出
2. **在 switch 語句中利用模式匹配**
3. **優先使用 switch 而不是 if-else 鏈**處理多個條件
4. **使用 where 子句**進行附加過濾
5. **在 switch 語句中處理所有情況**
6. **使用結構化的錯誤處理**和 do-catch 塊

### 下一步
在下一個模組中，我們將探索 Swift 中的類和結構體，包括物件導向程式設計概念、繼承以及值類型和參考類型之間的差異。這將建立在我們對控制流的理解基礎上，展示如何將程式碼組織成可重用的元件。 